Vad är operatören “->” i C ++?

-> är inte operatör. Det är faktiskt två separata operatörer, - och>.
Den villkorliga koden minskar x medan den returnerar x: s ursprungliga (ej minskade) värde och jämför sedan originalvärdet med 0 med operatören>.
För att bättre förstå kan uttalandet skrivas enligt följande:
medan ((x--)> 0)
|
Eller för något helt annat ... x glider till 0.
medan (x - \
\
\
\
> 0)
printf ("% d", x);
Inte så matematiskt, men ... varje bild målar tusen ord ...
|
Det är en mycket komplicerad operatör, så även ISO / IEC JTC1 (Joint Technical Committee 1) placerade sin beskrivning i två olika delar av C ++ - standarden.
Bortsett från skämt är de två olika operatörer: - och> beskrivna i §5.2.6 / 2 respektive §5.9 i C ++ 03-standarden.
|
Det motsvarar
medan (x--> 0)
x-- (efter minskning) är ekvivalent med x = x-1 så koden förvandlas till:
medan (x> 0) {
x = x-1;
// logik
}
x--; // Inläggsminskningen gjord när x <= 0
|
x kan gå till noll ännu snabbare i motsatt riktning:
int x = 10;
medan (0 <---- x)
{
printf ("% d", x);
}
8 6 4 2
Du kan styra hastigheten med en pil!
int x = 100;
medan (0 <-------------------- x)
{
printf ("% d", x);
}
90 80 70 60 50 40 30 20 10
;)
|
Dess
#include 
int main (void) {
int x = 10;
medan (x--> 0) {// x går till 0
printf ("% d", x);
}
returnera 0;
}
Bara utrymmet gör att sakerna ser roliga ut, - minskningar och> jämför.
|
Användningen av -> har historisk relevans. Minskning var (och är fortfarande i vissa fall) snabbare än att öka på x86-arkitekturen. Att använda -> föreslår att x går till 0 och tilltalar dem med matematisk bakgrund.
|
medan (x--> 0)
är hur det analyseras.
|
Helt nörd, men jag kommer att använda det här:
#definiera som; medan
int main (int argc, char * argv [])
{
int n = atoi (argv [1]);
gör printf ("n är% d \ n", n) som (n -> 0);
returnera 0;
}
|
En bok jag läste (jag kommer inte ihåg rätt vilken bok) sa: Kompilatorer försöker analysera uttryck till den största symbolen genom att använda vänster-högerregeln.
I detta fall uttrycket:
x -> 0
Tolkar till största tokens:
token 1: x
token 2: -
token 3:>
token 4: 0
avsluta: x--> 0
Samma regel gäller för detta uttryck:
a ----- b
Efter analys:
token 1: a
token 2: -
token 3: -
token 4: -
token 5: b
avsluta: (a -) - - b
Jag hoppas att detta hjälper till att förstå det komplicerade uttrycket ^^
|
Detta är exakt samma som
medan (x--)
{
printf ("% d", x);
}
för icke-negativa siffror
|
Hur som helst, vi har en "går till" -operatör nu. "->" är lätt att komma ihåg som en riktning, och "medan x går till noll" betyder rakt.
Dessutom är det lite mer effektivt än "för (x = 10; x> 0; x -)" på vissa plattformar.
|
Den här koden jämför först x och 0 och minskar sedan x. (Sades också i det första svaret: Du minskar efter x och jämför sedan x och 0 med operatören>.) Se resultatet av den här koden:
9 8 7 6 5 4 3 2 1 0
Vi jämför nu först och sedan minskar genom att se 0 i utdata.
Om vi ​​först vill minska och sedan jämföra, använd den här koden:
#include 
int main (ogiltigt)
{
int x = 10;
medan (--x> 0) // x går till 0
{
printf ("% d", x);
}
returnera 0;
}
Den produktionen är:
9 8 7 6 5 4 3 2 1
|
Min kompilator skriver ut 9876543210 när jag kör den här koden.
#include 
int main ()
{
int x = 10;
medan (x -> 0) // x går till 0
{
std :: cout << x;
}
}
Som förväntat. Medan (x--> 0) betyder faktiskt medan (x> 0). X-- efterminskningarna x.
medan (x> 0)
{
x--;
std :: cout << x;
}
är ett annat sätt att skriva samma sak.
Det är trevligt att originalet ser ut som "medan x går till 0".
|
Det finns ett mellanrum mellan - och>. x minskas efter, det vill säga minskas efter kontroll av villkoret x> 0?
|
- är minskningsoperatören och> är den större än operatören.
De två operatörerna tillämpas som en enda som ->.
|
Det är en kombination av två operatörer. Först - är för att minska värdet och> är för att kontrollera om värdet är större än den högra operanden.
#include 
int main ()
{
int x = 10;
medan (x--> 0)
printf ("% d", x);
returnera 0;
}
Resultatet blir:
9 8 7 6 5 4 3 2 1 0
|
I själva verket är x efterminskande och med det villkoret kontrolleras. Det är inte ->, det är (x--)> 0
Obs: värdet på x ändras efter att villkoret har kontrollerats, eftersom det minskar efter det. Några liknande fall kan också förekomma, till exempel:
-> x -> 0
++> x ++> 0
-> = x -> = 0
++> = x ++> = 0
|
C och C ++ följer "maximum munch" -regeln. Samma sätt som a --- b översätts till (a--) - b, i ditt fall x -> 0 översätts till (x -)> 0.
Vad regeln i huvudsak säger är att uttryck från vänster till höger bildas genom att ta maximalt antal tecken som kommer att bilda ett giltigt uttryck.
|
Varför all komplikation?
Det enkla svaret på den ursprungliga frågan är bara:
#include 
int main ()
{
int x = 10;
medan (x>0)
{
printf ("% d", x);
x = x-1;
}
}
Det gör samma sak. Jag säger inte att du ska göra det så här, men det gör samma sak och skulle ha svarat på frågan i ett inlägg.
X-- är bara stenografi för ovanstående, och> är bara en vanlig större än operatör. Inget stort mysterium!
Det finns för många människor som gör enkla saker komplicerade idag;)
|
På det konventionella sättet skulle vi definiera ett tillstånd i parentes-parentes () och ett avslutande tillstånd inuti hängslen {}, men -> definierar båda samtidigt.
Till exempel:
int abc (ogiltigt)
{
int a = 5
medan ((a--)> 0) // Minskning och jämförelse båda samtidigt
{
// Kod
}
}
Detta minskar a och kör slingan medan a är större än 0.
Konventionellt skulle det vara som:
int abc (ogiltigt)
{
int a = 5;
medan (a> 0)
{
a--;
// Kod
}
a--;
}
Båda vägarna gör vi samma sak och uppnår samma mål.
|
(x -> 0) betyder (x--> 0).
Du kan använda (x ->) Utgång: 9 8 7 6 5 4 3 2 1 0
Du kan använda (- x> 0) Det är medelvärde (--x> 0) Output: 9 8 7 6 5 4 3 2 1
Du kan använda
(- \
\
x> 0)
Utgång: 9 8 7 6 5 4 3 2 1
Du kan använda
(\
\
x -> 0)
Utgång: 9 8 7 6 5 4 3 2 1 0
Du kan använda
(\
\
x -> 0
\
\
)
Utgång: 9 8 7 6 5 4 3 2 1 0
Du kan också använda
(
x
->
)
Utgång: 9 8 7 6 5 4 3 2 1 0
På samma sätt kan du prova många metoder för att utföra detta kommando framgångsrikt.
|
Här - är den unara efterminskningsoperatören.
medan (x--> 0) // x går till 0
{
printf ("% d", x);
}
I början kommer villkoret att utvärderas som
(x> 0) // 10> 0
Nu eftersom villkoret är sant kommer det att gå in i slingan med ett minskat värde
x-- // x = 9
Det är därför det första tryckta värdet är 9
Och så vidare. I den sista slingan x = 1, så är villkoret sant. Enligt den unary operatören ändrades värdet till x = 0 vid tidpunkten för utskrift.
Nu, x = 0, som utvärderar villkoret (x> 0) som falskt och medan slingan avslutas.
|
Detta -> är inte en operatör alls. Vi har en operatör som ->, men inte som ->. Det är bara en felaktig tolkning av medan (x--> 0) vilket helt enkelt betyder att x har postminskningsoperatören och den här slingan kommer att gå tills den är större än noll.
Ett annat enkelt sätt att skriva den här koden skulle vara medan (x--). While-slingan kommer att sluta när den får ett falskt tillstånd och här finns det bara ett fall, dvs 0. Så det kommer att sluta när x-värdet minskas till noll.
|
Mycket aktiv fråga. Tjäna 10 rykte för att svara på den här frågan. Kravet på rykte hjälper till att skydda denna fråga från skräppost och icke-svar-aktivitet.
Inte svaret du letar efter? Bläddra bland andra frågor taggade c ++ c operatörer kodformatering standarder-efterlevnad eller ställ din egen fråga.